home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / usenet / volume7 / nethack3 / patch7r < prev    next >
Encoding:
Internet Message Format  |  1990-02-26  |  56.5 KB

  1. Path: uunet!lll-winken!brutus.cs.uiuc.edu!zaphod.mps.ohio-state.edu!think!mintaka!mit-eddie!uw-beaver!zephyr.ens.tek.com!tekred!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v09i018:  NetHack3 -  display oriented dungeons & dragons (Ver. 3.0), Patch7r
  5. Message-ID: <5232@tekred.CNA.TEK.COM>
  6. Date: 24 Feb 90 01:00:59 GMT
  7. Sender: news@tekred.CNA.TEK.COM
  8. Lines: 2202
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: Izchak Miller <izchak@linc.cis.upenn.edu>
  12. Posting-number: Volume 9, Issue 18
  13. Archive-name: NetHack3/Patch7r
  14. Patch-To: NetHack3: Volume 7, Issue 56-93
  15.  
  16.  
  17.  
  18. #! /bin/sh
  19. # This is a shell archive.  Remove anything before this line, then unpack
  20. # it by saving it into a file and typing "sh file".  To overwrite existing
  21. # files, type "sh file -c".  You can also feed this as standard input via
  22. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  23. # will see the following message at the end:
  24. #        "End of archive 18 (of 30)."
  25. # Contents:  patch7.12
  26. # Wrapped by billr@saab on Thu Feb 22 16:18:37 1990
  27. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  28. if test -f 'patch7.12' -a "${1}" != "-c" ; then 
  29.   echo shar: Will not clobber existing file \"'patch7.12'\"
  30. else
  31. echo shar: Extracting \"'patch7.12'\" \(53746 characters\)
  32. sed "s/^X//" >'patch7.12' <<'END_OF_FILE'
  33. X*** src/Old/mondata.c    Mon Feb 19 20:32:59 1990
  34. X--- src/mondata.c    Thu Jan 25 22:13:40 1990
  35. X***************
  36. X*** 1,4 ****
  37. X! /*    SCCS Id: @(#)mondata.c    3.0    89/11/19
  38. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  39. X  /* NetHack may be freely redistributed.  See license for details. */
  40. X  
  41. X--- 1,4 ----
  42. X! /*    SCCS Id: @(#)mondata.c    3.0    89/11/21
  43. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  44. X  /* NetHack may be freely redistributed.  See license for details. */
  45. X  
  46. X***************
  47. X*** 8,13 ****
  48. X--- 8,15 ----
  49. X  
  50. X  /*    These routines provide basic data for any type of monster. */
  51. X  
  52. X+ #ifdef OVL0
  53. X+ 
  54. X  boolean
  55. X  attacktype(ptr, atyp)
  56. X      register struct    permonst    *ptr;
  57. X***************
  58. X*** 21,32 ****
  59. X      return(FALSE);
  60. X  }
  61. X  
  62. X  boolean
  63. X  resists_ston(ptr)    /* returns TRUE if monster is petrify resistant */
  64. X      register struct permonst *ptr;
  65. X  {
  66. X!     return (ptr->mflags1 & M1_STON_RES || dmgtype(ptr, AD_STON) ||
  67. X!         dmgtype(ptr, AD_ACID));
  68. X  }
  69. X  
  70. X  boolean
  71. X--- 23,36 ----
  72. X      return(FALSE);
  73. X  }
  74. X  
  75. X+ #endif /* OVL0 */
  76. X+ #ifdef OVLB
  77. X+ 
  78. X  boolean
  79. X  resists_ston(ptr)    /* returns TRUE if monster is petrify resistant */
  80. X      register struct permonst *ptr;
  81. X  {
  82. X!     return (ptr->mflags1 & (M1_STON_RES | M1_ACID) || dmgtype(ptr, AD_STON));
  83. X  }
  84. X  
  85. X  boolean
  86. X***************
  87. X*** 37,42 ****
  88. X--- 41,49 ----
  89. X      return(is_undead(ptr) || is_demon(ptr) || is_were(ptr));
  90. X  }
  91. X  
  92. X+ #endif /* OVLB */
  93. X+ #ifdef OVL0
  94. X+ 
  95. X  boolean
  96. X  ranged_attk(ptr)    /* returns TRUE if monster can attack at range */
  97. X      register struct permonst *ptr;
  98. X***************
  99. X*** 46,51 ****
  100. X--- 53,61 ----
  101. X          attacktype(ptr, AT_MAGC));
  102. X  }
  103. X  
  104. X+ #endif /* OVL0 */
  105. X+ #ifdef OVL1
  106. X+ 
  107. X  boolean
  108. X  can_track(ptr)        /* returns TRUE if monster can track well */
  109. X      register struct permonst *ptr;
  110. X***************
  111. X*** 56,61 ****
  112. X--- 66,74 ----
  113. X      return(haseyes(ptr));
  114. X  }
  115. X  
  116. X+ #endif /* OVL1 */
  117. X+ #ifdef OVLB
  118. X+ 
  119. X  #ifdef POLYSELF
  120. X  boolean
  121. X  breakarm(ptr)    /* creature will break out of armor */
  122. X***************
  123. X*** 82,87 ****
  124. X--- 95,103 ----
  125. X  }
  126. X  #endif
  127. X  
  128. X+ #endif /* OVLB */
  129. X+ #ifdef OVL1
  130. X+ 
  131. X  boolean
  132. X  sticks(ptr)    /* creature sticks other creatures it hits */
  133. X      register struct permonst *ptr;
  134. X***************
  135. X*** 121,132 ****
  136. X  monsndx(ptr)        /* return an index into the mons array */
  137. X      struct    permonst    *ptr;
  138. X  {
  139. X      register int    i;
  140. X  
  141. X      if(ptr == &playermon) return(-1);
  142. X! 
  143. X      i = (int)(ptr - &mons[0]);
  144. X! 
  145. X      if(i < 0 || i >= NUMMONS) {    
  146. X          panic("monsndx - could not index monster (%x)", ptr);
  147. X          return FALSE;        /* will not get here */
  148. X--- 137,156 ----
  149. X  monsndx(ptr)        /* return an index into the mons array */
  150. X      struct    permonst    *ptr;
  151. X  {
  152. X+ #ifdef LATTICE_504_BUG
  153. X+     register int d;
  154. X+ /* no problem - see, pspace IS bounded (and fits in 32 bits!) KL */
  155. X+ const int pspace= sizeof(struct permonst[NUMMONS])/NUMMONS;
  156. X+ #endif
  157. X      register int    i;
  158. X  
  159. X      if(ptr == &playermon) return(-1);
  160. X! #ifndef LATTICE_504_BUG
  161. X      i = (int)(ptr - &mons[0]);
  162. X! #else
  163. X!     d=(int)((int)ptr-(int)&mons[0]);
  164. X!     i= d/pspace;
  165. X! #endif
  166. X      if(i < 0 || i >= NUMMONS) {    
  167. X          panic("monsndx - could not index monster (%x)", ptr);
  168. X          return FALSE;        /* will not get here */
  169. X***************
  170. X*** 175,186 ****
  171. X      if (!strncmp(str, "cavewomen", 9)) return PM_CAVEWOMAN;
  172. X      if (!strncmp(str, "zruties", 7)) return PM_ZRUTY;
  173. X      if (!strncmp(str, "djinn", 5)) return PM_DJINNI;
  174. X-         /* be careful with "ies"; "priest", "zombies" */
  175. X      for(s=str; *s; s++) {
  176. X          if (!strncmp(s, "vortices", 8)) {
  177. X              Strcpy(s+4, "ex");
  178. X              break;
  179. X          }
  180. X          if (!strncmp(s, "jellies", 7) || !strncmp(s, "mummies", 7)) {
  181. X              Strcpy(s+4, "y");
  182. X              break;
  183. X--- 199,210 ----
  184. X      if (!strncmp(str, "cavewomen", 9)) return PM_CAVEWOMAN;
  185. X      if (!strncmp(str, "zruties", 7)) return PM_ZRUTY;
  186. X      if (!strncmp(str, "djinn", 5)) return PM_DJINNI;
  187. X      for(s=str; *s; s++) {
  188. X          if (!strncmp(s, "vortices", 8)) {
  189. X              Strcpy(s+4, "ex");
  190. X              break;
  191. X          }
  192. X+         /* be careful with "ies"; "priest", "zombies" */
  193. X          if (!strncmp(s, "jellies", 7) || !strncmp(s, "mummies", 7)) {
  194. X              Strcpy(s+4, "y");
  195. X              break;
  196. X***************
  197. X*** 203,208 ****
  198. X--- 227,235 ----
  199. X      return mntmp;
  200. X  }
  201. X  
  202. X+ #endif /* OVL1 */
  203. X+ #ifdef OVLB
  204. X+ 
  205. X  #ifdef POLYSELF
  206. X  boolean
  207. X  webmaker(ptr)   /* creature can spin a web */
  208. X***************
  209. X*** 220,228 ****
  210. X  #if defined(ALTARS) && defined(THEOLOGY)
  211. X      if (mtmp->ispriest) return !EPRI(mtmp)->ismale;
  212. X  #endif
  213. X!     return !!(mtmp->data->mflags1 & M1_FEM);
  214. X  }
  215. X  
  216. X  /* Gender function.  Differs from is_female() in that 1) It allows the monster
  217. X   * type of a polymorphed shopkeeper to override ESHK(mtmp)->ismale, and 2)
  218. X   * it returns 3 values (0=male, 1=female, 2=none) instead of 2.
  219. X--- 247,258 ----
  220. X  #if defined(ALTARS) && defined(THEOLOGY)
  221. X      if (mtmp->ispriest) return !EPRI(mtmp)->ismale;
  222. X  #endif
  223. X!     return !!(mtmp->data->mflags2 & M2_FEM);
  224. X  }
  225. X  
  226. X+ #endif /* OVLB */
  227. X+ #ifdef OVL2
  228. X+ 
  229. X  /* Gender function.  Differs from is_female() in that 1) It allows the monster
  230. X   * type of a polymorphed shopkeeper to override ESHK(mtmp)->ismale, and 2)
  231. X   * it returns 3 values (0=male, 1=female, 2=none) instead of 2.
  232. X***************
  233. X*** 232,238 ****
  234. X      register struct monst *mtmp;
  235. X  {
  236. X      if (!humanoid(mtmp->data)) return 2;
  237. X!     if (mtmp->data->mflags1 & M1_FEM) return 1;
  238. X      if (mtmp->data == &mons[PM_CAVEMAN]
  239. X          || mtmp->data == &mons[PM_PRIEST]
  240. X  #ifdef INFERNO
  241. X--- 262,268 ----
  242. X      register struct monst *mtmp;
  243. X  {
  244. X      if (!humanoid(mtmp->data)) return 2;
  245. X!     if (mtmp->data->mflags2 & M2_FEM) return 1;
  246. X      if (mtmp->data == &mons[PM_CAVEMAN]
  247. X          || mtmp->data == &mons[PM_PRIEST]
  248. X  #ifdef INFERNO
  249. X***************
  250. X*** 246,256 ****
  251. X      return 0;
  252. X  }
  253. X  
  254. X  boolean
  255. X  levl_follower(mtmp)
  256. X  register struct monst *mtmp;
  257. X  {
  258. X!     return (mtmp->mtame || (mtmp->data->mflags1 & M1_STALK) || is_fshk(mtmp)
  259. X          || (mtmp->iswiz && !mon_has_amulet(mtmp)));
  260. X  }
  261. X  
  262. X--- 276,289 ----
  263. X      return 0;
  264. X  }
  265. X  
  266. X+ #endif /* OVL2 */
  267. X+ #ifdef OVLB
  268. X+ 
  269. X  boolean
  270. X  levl_follower(mtmp)
  271. X  register struct monst *mtmp;
  272. X  {
  273. X!     return (mtmp->mtame || (mtmp->data->mflags2 & M2_STALK) || is_fshk(mtmp)
  274. X          || (mtmp->iswiz && !mon_has_amulet(mtmp)));
  275. X  }
  276. X  
  277. X***************
  278. X*** 280,285 ****
  279. X--- 313,326 ----
  280. X  const int grownups[][2] = { {PM_LITTLE_DOG, PM_DOG}, {PM_DOG, PM_LARGE_DOG},
  281. X      {PM_HELL_HOUND_PUP, PM_HELL_HOUND}, {PM_KITTEN, PM_HOUSECAT},
  282. X      {PM_HOUSECAT, PM_LARGE_CAT}, {PM_BABY_GRAY_DRAGON, PM_GRAY_DRAGON},
  283. X+     {PM_KOBOLD, PM_LARGE_KOBOLD}, {PM_LARGE_KOBOLD, PM_KOBOLD_LORD},
  284. X+     {PM_GNOME, PM_GNOME_LORD}, {PM_GNOME_LORD, PM_GNOME_KING},
  285. X+     {PM_DWARF, PM_DWARF_LORD}, {PM_DWARF_LORD, PM_DWARF_KING},
  286. X+     {PM_SMALL_MIMIC, PM_LARGE_MIMIC}, {PM_LARGE_MIMIC, PM_GIANT_MIMIC},
  287. X+     {PM_BAT, PM_GIANT_BAT},
  288. X+     {PM_LICH, PM_DEMILICH}, {PM_DEMILICH, PM_MASTER_LICH},
  289. X+     {PM_OGRE, PM_OGRE_LORD}, {PM_OGRE_LORD, PM_OGRE_KING},
  290. X+     {PM_VAMPIRE, PM_VAMPIRE_LORD},
  291. X      {PM_BABY_RED_DRAGON, PM_RED_DRAGON},
  292. X      {PM_BABY_WHITE_DRAGON, PM_WHITE_DRAGON},
  293. X      {PM_BABY_BLUE_DRAGON, PM_BLUE_DRAGON},
  294. X***************
  295. X*** 300,305 ****
  296. X--- 341,347 ----
  297. X      {PM_SERGEANT, PM_LIEUTENANT},
  298. X      {PM_LIEUTENANT, PM_CAPTAIN},
  299. X  #endif
  300. X+     {PM_BABY_CROCODILE, PM_CROCODILE},
  301. X      {-1,-1}
  302. X  };
  303. X  
  304. X***************
  305. X*** 324,329 ****
  306. X--- 366,387 ----
  307. X  }
  308. X  
  309. X  
  310. X+ const char *
  311. X+ locomotion(ptr, def)
  312. X+ const struct permonst *ptr;
  313. X+ const char *def;
  314. X+ {
  315. X+     return (
  316. X+         is_floater(ptr) ? "float" :
  317. X+         is_flyer(ptr) ? "fly" :
  318. X+         slithy(ptr) ? "slither" :
  319. X+         amorphous(ptr) ? "ooze" :
  320. X+         nolimbs(ptr) ? "crawl" :
  321. X+         def
  322. X+            );
  323. X+ 
  324. X+ }
  325. X+ 
  326. X  #ifdef STUPID_CPP    /* otherwise these functions are macros in mondata.h */
  327. X  
  328. X  int
  329. X***************
  330. X*** 362,387 ****
  331. X  }
  332. X  
  333. X  int
  334. X! is_animal(ptr) struct permonst *ptr; {
  335. X!     return((ptr->mflags1 & M1_ANIMAL) != 0L);
  336. X  }
  337. X  
  338. X  int
  339. X! humanoid(ptr) struct permonst *ptr; {
  340. X!     return((ptr->mflags1 & M1_HUMANOID) != 0L);
  341. X  }
  342. X  
  343. X  int
  344. X! is_undead(ptr) struct permonst *ptr; {
  345. X!     return((ptr->mflags1 & M1_UNDEAD) != 0L);
  346. X  }
  347. X  
  348. X  int
  349. X! is_were(ptr) struct permonst *ptr; {
  350. X!     return((ptr->mflags1 & M1_WERE) != 0L);
  351. X  }
  352. X  
  353. X! int haseyes(ptr) struct permonst *ptr; {
  354. X      return((ptr->mflags1 & M1_NOEYES) == 0L);
  355. X  }
  356. X  
  357. X--- 420,451 ----
  358. X  }
  359. X  
  360. X  int
  361. X! amorphous(ptr) struct permonst *ptr; {
  362. X!     return((ptr->mflags1 & M1_AMORPHOUS) != 0L);
  363. X  }
  364. X  
  365. X  int
  366. X! tunnels(ptr) struct permonst *ptr; {
  367. X!     return((ptr->mflags1 & M1_TUNNEL) != 0L);
  368. X  }
  369. X  
  370. X  int
  371. X! needspick(ptr) struct permonst *ptr; {
  372. X!     return((ptr->mflags1 & M1_NEEDPICK) != 0L);
  373. X  }
  374. X  
  375. X  int
  376. X! hides_under(ptr) struct permonst *ptr; {
  377. X!     return((ptr->mflags1 & M1_CONCEAL) != 0L);
  378. X  }
  379. X  
  380. X! int
  381. X! is_hider(ptr) struct permonst *ptr; {
  382. X!     return((ptr->mflags1 & M1_HIDE) != 0L);
  383. X! }
  384. X! 
  385. X! int
  386. X! haseyes(ptr) struct permonst *ptr; {
  387. X      return((ptr->mflags1 & M1_NOEYES) == 0L);
  388. X  }
  389. X  
  390. X***************
  391. X*** 391,408 ****
  392. X  }
  393. X  
  394. X  int
  395. X! lays_eggs(ptr) struct permonst *ptr; {
  396. X!     return((ptr->mflags1 & M1_EGGS) != 0L);
  397. X  }
  398. X  
  399. X  int
  400. X! poisonous(ptr) struct permonst *ptr; {
  401. X!     return((ptr->mflags1 & M1_POIS) != 0L);
  402. X  }
  403. X  
  404. X  int
  405. X! resists_poison(ptr) struct permonst *ptr; {
  406. X!     return((ptr->mflags1 & (M1_POIS | M1_POIS_RES)) != 0L);
  407. X  }
  408. X  
  409. X  int
  410. X--- 455,495 ----
  411. X  }
  412. X  
  413. X  int
  414. X! nolimbs(ptr) struct permonst *ptr; {
  415. X!     return((ptr->mflags1 & M1_NOLIMBS) == M1_NOLIMBS);
  416. X  }
  417. X  
  418. X+ # ifdef POLYSELF
  419. X  int
  420. X! polyok(ptr) struct permonst *ptr; {
  421. X!     return((ptr->mflags1 & M1_NOPOLY) == 0L);
  422. X  }
  423. X+ # endif
  424. X  
  425. X  int
  426. X! is_whirly(ptr) struct permonst *ptr; {
  427. X!     return((ptr->mlet == S_VORTEX) || 
  428. X!            (ptr == &mons[PM_AIR_ELEMENTAL]));
  429. X! }
  430. X! 
  431. X! int
  432. X! humanoid(ptr) struct permonst *ptr; {
  433. X!     return((ptr->mflags1 & M1_HUMANOID) != 0L);
  434. X! }
  435. X! 
  436. X! int
  437. X! is_animal(ptr) struct permonst *ptr; {
  438. X!     return((ptr->mflags1 & M1_ANIMAL) != 0L);
  439. X! }
  440. X! 
  441. X! int
  442. X! slithy(ptr) struct permonst *ptr; {
  443. X!     return((ptr->mflags1 & M1_SLITHY) != 0L);
  444. X! }
  445. X! 
  446. X! int
  447. X! thick_skinned(ptr) struct permonst *ptr; {
  448. X!     return((ptr->mflags1 & M1_THICK_HIDE) != 0L);
  449. X  }
  450. X  
  451. X  int
  452. X***************
  453. X*** 411,423 ****
  454. X  }
  455. X  
  456. X  int
  457. X  resists_cold(ptr) struct permonst *ptr; {
  458. X      return((ptr->mflags1 & M1_COLD_RES) != 0L);
  459. X  }
  460. X  
  461. X  int
  462. X! resists_acid(ptr) struct permonst *ptr; {
  463. X!     return(dmgtype(ptr, AD_ACID));
  464. X  }
  465. X  
  466. X  int
  467. X--- 498,516 ----
  468. X  }
  469. X  
  470. X  int
  471. X+ resists_sleep(ptr) struct permonst *ptr; {
  472. X+     return((ptr->mflags1 & M1_SLEE_RES) != 0L || is_undead(ptr));
  473. X+ }
  474. X+ 
  475. X+ int
  476. X  resists_cold(ptr) struct permonst *ptr; {
  477. X      return((ptr->mflags1 & M1_COLD_RES) != 0L);
  478. X  }
  479. X  
  480. X  int
  481. X! resists_disint(ptr) struct permonst *ptr; {
  482. X!     return(ptr == &mons[PM_BLACK_DRAGON] ||
  483. X!         ptr == &mons[PM_BABY_BLACK_DRAGON]);
  484. X  }
  485. X  
  486. X  int
  487. X***************
  488. X*** 426,439 ****
  489. X  }
  490. X  
  491. X  int
  492. X! resists_sleep(ptr) struct permonst *ptr; {
  493. X!     return((ptr->mflags1 & (M1_SLEE_RES | M1_UNDEAD)) != 0L);
  494. X  }
  495. X  
  496. X  int
  497. X! resists_disint(ptr) struct permonst *ptr; {
  498. X!     return(ptr == &mons[PM_BLACK_DRAGON] ||
  499. X!         ptr == &mons[PM_BABY_BLACK_DRAGON]);
  500. X  }
  501. X  
  502. X  int
  503. X--- 519,541 ----
  504. X  }
  505. X  
  506. X  int
  507. X! resists_acid(ptr) struct permonst *ptr; {
  508. X!     return((ptr->mflags1 & M1_ACID) != 0L);
  509. X  }
  510. X  
  511. X  int
  512. X! acidic(ptr) struct permonst *ptr; {
  513. X!     return((ptr->mflags1 & M1_ACID) != 0L);
  514. X! }
  515. X! 
  516. X! int
  517. X! resists_poison(ptr) struct permonst *ptr; {
  518. X!     return((ptr->mflags1 & (M1_POIS | M1_POIS_RES)) != 0L);
  519. X! }
  520. X! 
  521. X! int
  522. X! poisonous(ptr) struct permonst *ptr; {
  523. X!     return((ptr->mflags1 & M1_POIS) != 0L);
  524. X  }
  525. X  
  526. X  int
  527. X***************
  528. X*** 482,511 ****
  529. X  }
  530. X  
  531. X  int
  532. X! hides_under(ptr) struct permonst *ptr; {
  533. X!     return((ptr->mflags2 & M2_CONCEAL) != 0L);
  534. X! }
  535. X! 
  536. X! int
  537. X! is_hider(ptr) struct permonst *ptr; {
  538. X!     return((ptr->mflags2 & M2_HIDE) != 0L);
  539. X! }
  540. X! 
  541. X! # ifdef POLYSELF
  542. X! int
  543. X! polyok(ptr) struct permonst *ptr; {
  544. X!     return((ptr->mflags1 & M1_NOPOLY) == 0L);
  545. X! }
  546. X! # endif /* POLYSELF */
  547. X! 
  548. X! int
  549. X! tunnels(ptr) struct permonst *ptr; {
  550. X!     return((ptr->mflags2 & M2_TUNNEL) != 0L);
  551. X  }
  552. X  
  553. X  int
  554. X! needspick(ptr) struct permonst *ptr; {
  555. X!     return((ptr->mflags2 & M2_NEEDPICK) != 0L);
  556. X  }
  557. X  
  558. X  int
  559. X--- 584,596 ----
  560. X  }
  561. X  
  562. X  int
  563. X! is_undead(ptr) struct permonst *ptr; {
  564. X!     return((ptr->mflags2 & M2_UNDEAD) != 0L);
  565. X  }
  566. X  
  567. X  int
  568. X! is_were(ptr) struct permonst *ptr; {
  569. X!     return((ptr->mflags2 & M2_WERE) != 0L);
  570. X  }
  571. X  
  572. X  int
  573. X***************
  574. X*** 531,536 ****
  575. X--- 616,627 ----
  576. X  # endif /* GOLEMS */
  577. X  
  578. X  int
  579. X+ is_domestic(ptr) struct permonst *ptr; {
  580. X+     return((ptr->mflags2 & M2_DOMESTIC) != 0L);
  581. X+ }
  582. X+ 
  583. X+ 
  584. X+ int
  585. X  is_orc(ptr) struct permonst *ptr; {
  586. X      return((ptr->mflags2 & M2_ORC) != 0L);
  587. X  }
  588. X***************
  589. X*** 551,663 ****
  590. X  }
  591. X  
  592. X  int
  593. X- throws_rocks(ptr) struct permonst *ptr; {
  594. X-     return((ptr->mflags2 & M2_ROCKTHROW) != 0L);
  595. X- }
  596. X- 
  597. X- int
  598. X  is_wanderer(ptr) struct permonst *ptr; {
  599. X      return((ptr->mflags2 & M2_WANDER) != 0L);
  600. X  }
  601. X  
  602. X  int
  603. X! is_lord(ptr) struct permonst *ptr; {
  604. X!     return((ptr->mflags1 & M1_LORD) != 0L);
  605. X  }
  606. X  
  607. X  int
  608. X! is_prince(ptr) struct permonst *ptr; {
  609. X!     return((ptr->mflags1 & M1_PRINCE) != 0L);
  610. X  }
  611. X  
  612. X- # ifdef INFERNO
  613. X  int
  614. X! is_ndemon(ptr) struct permonst *ptr; {
  615. X!     return(is_demon(ptr) &&
  616. X!         (ptr->mflags1 & (M1_LORD | M1_PRINCE)) == 0L);
  617. X  }
  618. X! # else
  619. X  int
  620. X! is_ndemon(ptr) struct permonst *ptr; {
  621. X!     return(ptr == &mons[PM_DEMON]);
  622. X  }
  623. X- # endif
  624. X  
  625. X  int
  626. X! is_dlord(ptr) struct permonst *ptr; {
  627. X!     return(is_demon(ptr) && is_lord(ptr));
  628. X  }
  629. X  
  630. X  int
  631. X! is_dprince(ptr) struct permonst *ptr; {
  632. X!     return(is_demon(ptr) && is_prince(ptr));
  633. X  }
  634. X  
  635. X  int
  636. X! type_is_pname(ptr) struct permonst *ptr; {
  637. X!     return((ptr->mflags2 & M2_PNAME) != 0L);
  638. X  }
  639. X  
  640. X  int
  641. X! always_hostile(ptr) struct permonst *ptr; {
  642. X!     return((ptr->mflags2 & M2_HOSTILE) != 0L);
  643. X  }
  644. X  
  645. X  int
  646. X! always_peaceful(ptr) struct permonst *ptr; {
  647. X!     return((ptr->mflags2 & M2_PEACEFUL) != 0L);
  648. X  }
  649. X  
  650. X  int
  651. X! strongmonst(ptr) struct permonst *ptr; {
  652. X!     return((ptr->mflags2 & M2_STRONG) != 0L);
  653. X  }
  654. X  
  655. X  int
  656. X! extra_nasty(ptr) struct permonst *ptr; {
  657. X!     return((ptr->mflags2 & M2_NASTY) != 0L);
  658. X  }
  659. X  
  660. X- # ifdef POLYSELF
  661. X  int
  662. X! can_breathe(ptr) struct permonst *ptr; {
  663. X!     return(attacktype(ptr, AT_BREA));
  664. X  }
  665. X  
  666. X  int
  667. X! cantwield(ptr) struct permonst *ptr; {
  668. X!     return(nohands(ptr) || verysmall(ptr));
  669. X  }
  670. X  
  671. X  int
  672. X! cantweararm(ptr) struct permonst *ptr; {
  673. X!     return(breakarm(ptr) || sliparm(ptr));
  674. X  }
  675. X- # endif /* POLYSELF */
  676. X  
  677. X  int
  678. X! nolimbs(ptr) struct permonst *ptr; {
  679. X!     return((ptr->mflags2 & M2_NOLIMBS) != 0L);
  680. X  }
  681. X  
  682. X  int
  683. X! carnivorous(ptr) struct permonst *ptr; {
  684. X!     return((ptr->mflags2 & M2_CARNIVORE) != 0L);
  685. X  }
  686. X! 
  687. X  int
  688. X! herbivorous(ptr) struct permonst *ptr; {
  689. X!     return((ptr->mflags2 & M2_HERBIVORE) != 0L);
  690. X  }
  691. X  
  692. X  int
  693. X! thick_skinned(ptr) struct permonst *ptr; {
  694. X!     return((ptr->mflags2 & M2_THICK_HIDE) != 0L);
  695. X  }
  696. X  
  697. X  int
  698. X! amorphous(ptr) struct permonst *ptr; {
  699. X!     return((ptr->mflags2 & M2_AMORPHOUS) != 0L);
  700. X  }
  701. X  
  702. X  #endif /* STUPID_CPP */
  703. X--- 642,751 ----
  704. X  }
  705. X  
  706. X  int
  707. X  is_wanderer(ptr) struct permonst *ptr; {
  708. X      return((ptr->mflags2 & M2_WANDER) != 0L);
  709. X  }
  710. X  
  711. X  int
  712. X! always_hostile(ptr) struct permonst *ptr; {
  713. X!     return((ptr->mflags2 & M2_HOSTILE) != 0L);
  714. X  }
  715. X  
  716. X  int
  717. X! always_peaceful(ptr) struct permonst *ptr; {
  718. X!     return((ptr->mflags2 & M2_PEACEFUL) != 0L);
  719. X  }
  720. X  
  721. X  int
  722. X! extra_nasty(ptr) struct permonst *ptr; {
  723. X!     return((ptr->mflags2 & M2_NASTY) != 0L);
  724. X  }
  725. X! 
  726. X  int
  727. X! strongmonst(ptr) struct permonst *ptr; {
  728. X!     return((ptr->mflags2 & M2_STRONG) != 0L);
  729. X  }
  730. X  
  731. X+ # ifdef POLYSELF
  732. X  int
  733. X! can_breathe(ptr) struct permonst *ptr; {
  734. X!     return(attacktype(ptr, AT_BREA));
  735. X  }
  736. X  
  737. X  int
  738. X! cantwield(ptr) struct permonst *ptr; {
  739. X!     return(nohands(ptr) || verysmall(ptr));
  740. X  }
  741. X  
  742. X  int
  743. X! cantweararm(ptr) struct permonst *ptr; {
  744. X!     return(breakarm(ptr) || sliparm(ptr));
  745. X  }
  746. X+ # endif /* POLYSELF */
  747. X  
  748. X  int
  749. X! carnivorous(ptr) struct permonst *ptr; {
  750. X!     return((ptr->mflags2 & M2_CARNIVORE) != 0L);
  751. X  }
  752. X  
  753. X  int
  754. X! herbivorous(ptr) struct permonst *ptr; {
  755. X!     return((ptr->mflags2 & M2_HERBIVORE) != 0L);
  756. X  }
  757. X  
  758. X  int
  759. X! metallivorous(ptr) struct permonst *ptr; {
  760. X!     return((ptr->mflags2 & M2_METALLIVORE) != 0L);
  761. X  }
  762. X  
  763. X  int
  764. X! lays_eggs(ptr) struct permonst *ptr; {
  765. X!     return((ptr->mflags2 & M2_EGGS) != 0L);
  766. X  }
  767. X  
  768. X  int
  769. X! throws_rocks(ptr) struct permonst *ptr; {
  770. X!     return((ptr->mflags2 & M2_ROCKTHROW) != 0L);
  771. X  }
  772. X  
  773. X  int
  774. X! type_is_pname(ptr) struct permonst *ptr; {
  775. X!     return((ptr->mflags2 & M2_PNAME) != 0L);
  776. X  }
  777. X  
  778. X  int
  779. X! is_lord(ptr) struct permonst *ptr; {
  780. X!     return((ptr->mflags2 & M2_LORD) != 0L);
  781. X  }
  782. X  
  783. X  int
  784. X! is_prince(ptr) struct permonst *ptr; {
  785. X!     return((ptr->mflags2 & M2_PRINCE) != 0L);
  786. X  }
  787. X  
  788. X+ # ifdef INFERNO
  789. X  int
  790. X! is_ndemon(ptr) struct permonst *ptr; {
  791. X!     return(is_demon(ptr) &&
  792. X!         (ptr->mflags2 & (M2_LORD | M2_PRINCE)) == 0L);
  793. X  }
  794. X! # else
  795. X  int
  796. X! is_ndemon(ptr) struct permonst *ptr; {
  797. X!     return(ptr == &mons[PM_DEMON]);
  798. X  }
  799. X+ # endif
  800. X  
  801. X  int
  802. X! is_dlord(ptr) struct permonst *ptr; {
  803. X!     return(is_demon(ptr) && is_lord(ptr));
  804. X  }
  805. X  
  806. X  int
  807. X! is_dprince(ptr) struct permonst *ptr; {
  808. X!     return(is_demon(ptr) && is_prince(ptr));
  809. X  }
  810. X  
  811. X  #endif /* STUPID_CPP */
  812. X+ 
  813. X+ #endif /* OVLB */
  814. X*** Old/monmove.c    Wed Feb 21 18:10:20 1990
  815. X--- src/monmove.c    Wed Feb 21 18:00:56 1990
  816. X***************
  817. X*** 1,7 ****
  818. X! /*    SCCS Id: @(#)monmove.c    3.0    88/11/10
  819. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  820. X  /* NetHack may be freely redistributed.  See license for details. */
  821. X  
  822. X  #include "hack.h"
  823. X  #include "mfndpos.h"
  824. X  #ifdef NAMED_ITEMS
  825. X--- 1,14 ----
  826. X! /*    SCCS Id: @(#)monmove.c    3.0    89/11/21
  827. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  828. X  /* NetHack may be freely redistributed.  See license for details. */
  829. X  
  830. X+ #ifndef LINT
  831. X+ # ifndef __STDC__
  832. X+ #define TRAP_H    /* comment line for pre-compiled headers */
  833. X+ /* block some unused #defines to avoid overloading some cpp's */
  834. X+ # endif
  835. X+ #endif
  836. X+ 
  837. X  #include "hack.h"
  838. X  #include "mfndpos.h"
  839. X  #ifdef NAMED_ITEMS
  840. X***************
  841. X*** 8,13 ****
  842. X--- 15,27 ----
  843. X  #  include "artifact.h"
  844. X  #endif
  845. X  
  846. X+ static void FDECL(distfleeck,(struct monst *,int *,int *,int *));
  847. X+ #ifdef POLYSELF
  848. X+ static boolean FDECL(itsstuck,(struct monst *));
  849. X+ #endif
  850. X+ 
  851. X+ #ifdef OVLB
  852. X+ 
  853. X  boolean /* TRUE : mtmp died */
  854. X  mb_trapped(mtmp)
  855. X  register struct monst *mtmp;
  856. X***************
  857. X*** 36,72 ****
  858. X      boolean canseeit = cansee(mtmp->mx, mtmp->my);
  859. X      here = &levl[mtmp->mx][mtmp->my];
  860. X  
  861. X      if(IS_ROCK(here->typ)) {
  862. X          /* Just ate something. */
  863. X!         if(here->typ == STONE) here->typ = CORR;
  864. X!         else if(IS_WALL(here->typ) &&
  865. X!             !(here->diggable & W_NONDIGGABLE)) {
  866. X!         if(flags.soundok && flags.verbose && !rn2(5))
  867. X!                You("hear the sound of crashing rock.");
  868. X!         if(!is_maze_lev) {
  869. X!           here->typ = DOOR;
  870. X!           here->doormask = D_NODOOR;
  871. X!         }
  872. X!         else
  873. X!           here->typ = ROOM;
  874. X!         mnewsym(mtmp->mx, mtmp->my);
  875. X!         }
  876. X!     }
  877. X!     /* Eats away door if present & closed or locked */
  878. X!     else if(IS_DOOR(here->typ) &&
  879. X!         (here->doormask & (D_LOCKED | D_CLOSED))) {
  880. X!         if(here->doormask & D_TRAPPED) {
  881. X!             here->doormask = D_NODOOR;
  882. X!             mnewsym(mtmp->mx, mtmp->my);
  883. X!             if(mb_trapped(mtmp)) return(FALSE);
  884. X!         } else {
  885. X!             if(!rn2(3) && flags.verbose) /* not too often.. */
  886. X!                 You("feel an unexpected draft of air.");
  887. X!             here->doormask = D_BROKEN;
  888. X!             mnewsym(mtmp->mx, mtmp->my);
  889. X          }
  890. X!         }
  891. X!     else return TRUE; /* it doesn't leave rocks if it didn't dig */
  892. X  
  893. X      /* Left behind a pile? */
  894. X      if(pile < 5) {
  895. X--- 50,88 ----
  896. X      boolean canseeit = cansee(mtmp->mx, mtmp->my);
  897. X      here = &levl[mtmp->mx][mtmp->my];
  898. X  
  899. X+     if (here->typ == SDOOR)
  900. X+         here->typ = DOOR;
  901. X      if(IS_ROCK(here->typ)) {
  902. X          /* Just ate something. */
  903. X!         if(IS_WALL(here->typ)) {
  904. X!         if (!(here->diggable & W_NONDIGGABLE)) {
  905. X!             if(flags.soundok && flags.verbose && !rn2(5))
  906. X!                        You("hear the sound of crashing rock.");
  907. X!             if(!is_maze_lev) {
  908. X!                   here->typ = DOOR;
  909. X!                   here->doormask = D_NODOOR;
  910. X!             }
  911. X!             else
  912. X!                   here->typ = ROOM;
  913. X          }
  914. X!         } else    
  915. X!             here->typ = CORR;
  916. X!         mnewsym(mtmp->mx, mtmp->my);
  917. X!     } else         /* Eats away door if present & closed or locked */
  918. X!         if(closed_door(mtmp->mx, mtmp->my)) {
  919. X!             if(here->doormask & D_TRAPPED) {
  920. X!                     here->doormask = D_NODOOR;
  921. X!                     if(mb_trapped(mtmp)) return(FALSE);
  922. X!             } else {
  923. X!                     if(!rn2(3) && flags.verbose)
  924. X!                     /* not too often.. */
  925. X!                         You("feel an unexpected draft of air.");
  926. X!                     here->doormask = D_BROKEN;
  927. X!             }
  928. X!                 mnewsym(mtmp->mx, mtmp->my);
  929. X!             } else 
  930. X!             /* it doesn't leave rocks if it didn't dig */
  931. X!             return TRUE; 
  932. X  
  933. X      /* Left behind a pile? */
  934. X      if(pile < 5) {
  935. X***************
  936. X*** 80,88 ****
  937. X--- 96,108 ----
  938. X          newsym(mtmp->mx,mtmp->my);
  939. X      else
  940. X          mnewsym(mtmp->mx,mtmp->my);
  941. X+     here->seen = FALSE;
  942. X      return(TRUE);
  943. X  }
  944. X  
  945. X+ #endif /* OVLB */
  946. X+ #ifdef OVL1
  947. X+ 
  948. X  int
  949. X  dochugw(mtmp)
  950. X      register struct monst *mtmp;
  951. X***************
  952. X*** 110,115 ****
  953. X--- 130,138 ----
  954. X      return(rd);
  955. X  }
  956. X  
  957. X+ #endif /* OVL1 */
  958. X+ #ifdef OVL2
  959. X+ 
  960. X  boolean
  961. X  onscary(x, y, mtmp)
  962. X  int x, y;
  963. X***************
  964. X*** 130,135 ****
  965. X--- 153,161 ----
  966. X              sobj_at(SCR_SCARE_MONSTER, x, y) != (struct obj *)0);
  967. X  }
  968. X  
  969. X+ #endif /* OVL2 */
  970. X+ #ifdef OVL1
  971. X+ 
  972. X  static void
  973. X  distfleeck(mtmp,inrange,nearby,scared)
  974. X  register struct monst *mtmp;
  975. X***************
  976. X*** 197,203 ****
  977. X      /* polymorph lycanthropes */
  978. X      were_change(mtmp);
  979. X  
  980. X!     if(mtmp->mfroz) {
  981. X          if (Hallucination) pmon(mtmp);
  982. X          return(0);    /* frozen monsters don't do anything */
  983. X      }
  984. X--- 223,229 ----
  985. X      /* polymorph lycanthropes */
  986. X      were_change(mtmp);
  987. X  
  988. X!     if(!mtmp->mcanmove) {
  989. X          if (Hallucination) pmon(mtmp);
  990. X          return(0);    /* frozen monsters don't do anything */
  991. X      }
  992. X***************
  993. X*** 239,262 ****
  994. X      /* check distance and scariness of attacks */
  995. X      distfleeck(mtmp,&inrange,&nearby,&scared);
  996. X  
  997. X! #ifdef INFERNO        /* Demonic Blackmail!!! */
  998. X!     if(nearby && is_demon(mdat) && mtmp->mpeaceful && !mtmp->mtame) {
  999. X          if (mtmp->mux != u.ux || mtmp->muy != u.uy) {
  1000. X              pline("%s whispers something to thin air.",
  1001. X                  cansee(mtmp->mux, mtmp->muy) ? Monnam(mtmp) : "It");
  1002. X! #ifdef POLYSELF
  1003. X              if (is_demon(uasmon)) rloc(mtmp);
  1004. X                /* "Good hunting, brother" */
  1005. X!             else
  1006. X! #endif
  1007. X!             if (is_lord(mdat) || is_prince(mdat)) {
  1008. X!               /* use is_lord instead of is_dlord */
  1009. X                  mtmp->minvis = 0;
  1010. X                  /* Why?  For the same reason in real demon talk */
  1011. X                  pline("%s gets angry.", Xmonnam(mtmp));
  1012. X                  mtmp->mpeaceful = 0;
  1013. X                  /* since no way is an image going to pay it off */
  1014. X              }
  1015. X          } else if(demon_talk(mtmp)) return(1);    /* you paid it off */
  1016. X      }
  1017. X  #endif
  1018. X--- 265,289 ----
  1019. X      /* check distance and scariness of attacks */
  1020. X      distfleeck(mtmp,&inrange,&nearby,&scared);
  1021. X  
  1022. X! #ifdef INFERNO        /* Demonic Blackmail! */
  1023. X!     if(nearby && mdat->msound == MS_BRIBE &&
  1024. X!        mtmp->mpeaceful && !mtmp->mtame) {
  1025. X          if (mtmp->mux != u.ux || mtmp->muy != u.uy) {
  1026. X              pline("%s whispers something to thin air.",
  1027. X                  cansee(mtmp->mux, mtmp->muy) ? Monnam(mtmp) : "It");
  1028. X! # ifdef POLYSELF
  1029. X              if (is_demon(uasmon)) rloc(mtmp);
  1030. X                /* "Good hunting, brother" */
  1031. X!             else {
  1032. X! # endif
  1033. X                  mtmp->minvis = 0;
  1034. X                  /* Why?  For the same reason in real demon talk */
  1035. X                  pline("%s gets angry.", Xmonnam(mtmp));
  1036. X                  mtmp->mpeaceful = 0;
  1037. X                  /* since no way is an image going to pay it off */
  1038. X+ # ifdef POLYSELF
  1039. X              }
  1040. X+ # endif
  1041. X          } else if(demon_talk(mtmp)) return(1);    /* you paid it off */
  1042. X      }
  1043. X  #endif
  1044. X***************
  1045. X*** 284,290 ****
  1046. X               break;
  1047. X               case 1:    /* monster moved */
  1048. X              /* Maybe it stepped on a trap and fell asleep... */
  1049. X!             if(mtmp->msleep || mtmp->mfroz) return(0);
  1050. X               if(!nearby && ranged_attk(mdat)) break;
  1051. X               else if(mdat->mmove <= 12) return(0);
  1052. X               break;
  1053. X--- 311,317 ----
  1054. X               break;
  1055. X               case 1:    /* monster moved */
  1056. X              /* Maybe it stepped on a trap and fell asleep... */
  1057. X!             if(mtmp->msleep || !mtmp->mcanmove) return(0);
  1058. X               if(!nearby && ranged_attk(mdat)) break;
  1059. X               else if(mdat->mmove <= 12) return(0);
  1060. X               break;
  1061. X***************
  1062. X*** 303,308 ****
  1063. X--- 330,340 ----
  1064. X      if(mtmp->wormno && !mtmp->mtame) wormhit(mtmp);
  1065. X  #endif
  1066. X  
  1067. X+     /* extra emotional attack for vile monsters */
  1068. X+     if(inrange && mtmp->data->msound == MS_CUSS &&
  1069. X+        !mtmp->minvis && !mtmp->mpeaceful && !rn2(5))
  1070. X+         cuss(mtmp);
  1071. X+ 
  1072. X      /* extra movement for fast monsters */
  1073. X      if(mdat->mmove-12 > rnd(12)) tmp = m_move(mtmp, 1);
  1074. X      return(tmp == 2);
  1075. X***************
  1076. X*** 330,335 ****
  1077. X--- 362,370 ----
  1078. X  }
  1079. X  #endif
  1080. X  
  1081. X+ #endif /* OVL1 */
  1082. X+ #ifdef OVL0
  1083. X+ 
  1084. X  int
  1085. X  m_move(mtmp, after)
  1086. X  register struct monst *mtmp;
  1087. X***************
  1088. X*** 341,346 ****
  1089. X--- 376,382 ----
  1090. X      schar chi;
  1091. X      boolean likegold=0, likegems=0, likeobjs=0, likemagic=0, conceals=0;
  1092. X      boolean likerock=0, can_tunnel=0;
  1093. X+     boolean can_open=0, can_unlock=0, doorbuster=0;
  1094. X      struct permonst *ptr = mtmp->data;
  1095. X      schar mmoved = 0;    /* not strictly nec.: chi >= 0 will do */
  1096. X      coord poss[9];
  1097. X***************
  1098. X*** 371,376 ****
  1099. X--- 407,415 ----
  1100. X               dlevel != rogue_level &&
  1101. X  #endif
  1102. X               (!needspick(ptr) || m_carrying(mtmp, PICK_AXE));
  1103. X+     can_open = !(nohands(ptr) || verysmall(ptr));
  1104. X+     can_unlock = ((can_open && m_carrying(mtmp, SKELETON_KEY)) || mtmp->iswiz);
  1105. X+     doorbuster = is_giant(ptr);
  1106. X  #ifdef WORM
  1107. X      if(mtmp->wormno) goto not_special;
  1108. X  #endif
  1109. X***************
  1110. X*** 390,397 ****
  1111. X  
  1112. X      /* and for the guard */
  1113. X      if(mtmp->isgd) {
  1114. X!         mmoved = gd_move();
  1115. X!         goto postmov;
  1116. X      }
  1117. X  
  1118. X      /* and the wiz already got special treatment */
  1119. X--- 429,438 ----
  1120. X  
  1121. X      /* and for the guard */
  1122. X      if(mtmp->isgd) {
  1123. X!         mmoved = gd_move(mtmp);
  1124. X!         if(mmoved == -2) return(2);
  1125. X!         if(mmoved >= 0) goto postmov;
  1126. X!         mmoved = 0;
  1127. X      }
  1128. X  
  1129. X      /* and the wiz already got special treatment */
  1130. X***************
  1131. X*** 411,422 ****
  1132. X  #ifdef MAIL
  1133. X      if(ptr == &mons[PM_MAIL_DAEMON]) {
  1134. X          if(flags.soundok && canseemon(mtmp))
  1135. X!         pline("\"I'm late!\"");
  1136. X          mongone(mtmp);
  1137. X          return(2);        
  1138. X      }
  1139. X  #endif
  1140. X- 
  1141. X      /* teleport if that lies in our nature */
  1142. X      if(ptr == &mons[PM_TENGU] && !rn2(5)) {
  1143. X          if(mtmp->mhp < 7 || mtmp->mpeaceful || rn2(2))
  1144. X--- 452,462 ----
  1145. X  #ifdef MAIL
  1146. X      if(ptr == &mons[PM_MAIL_DAEMON]) {
  1147. X          if(flags.soundok && canseemon(mtmp))
  1148. X!         verbalize("I'm late!");
  1149. X          mongone(mtmp);
  1150. X          return(2);        
  1151. X      }
  1152. X  #endif
  1153. X      /* teleport if that lies in our nature */
  1154. X      if(ptr == &mons[PM_TENGU] && !rn2(5)) {
  1155. X          if(mtmp->mhp < 7 || mtmp->mpeaceful || rn2(2))
  1156. X***************
  1157. X*** 433,438 ****
  1158. X--- 473,481 ----
  1159. X      appr = 1;
  1160. X      if(mtmp->mflee) appr = -1;
  1161. X      if(mtmp->mconf || (Invis && !perceives(ptr)) ||  !mtmp->mcansee ||
  1162. X+ #ifdef POLYSELF
  1163. X+        (u.usym == S_MIMIC_DEF) || u.uundetected ||
  1164. X+ #endif
  1165. X         (mtmp->mpeaceful && !mtmp->isshk) ||    /* allow shks to follow */
  1166. X         ((ptr->mlet == S_STALKER || ptr->mlet == S_BAT ||
  1167. X           ptr->mlet == S_YLIGHT) && !rn2(3)))
  1168. X***************
  1169. X*** 536,541 ****
  1170. X--- 579,587 ----
  1171. X      if (is_human(ptr)) flag |= ALLOW_SSM;
  1172. X      if (is_undead(ptr)) flag |= NOGARLIC;
  1173. X      if (throws_rocks(ptr)) flag |= ALLOW_ROCK;
  1174. X+     if (can_open) flag |= OPENDOOR;
  1175. X+     if (can_unlock) flag |= UNLOCKDOOR;
  1176. X+     if (doorbuster) flag |= BUSTDOOR;
  1177. X      cnt = mfndpos(mtmp, poss, info, flag);
  1178. X      chcnt = 0;
  1179. X      chi = -1;
  1180. X***************
  1181. X*** 577,587 ****
  1182. X           */
  1183. X          if((info[chi] & ALLOW_M) ||
  1184. X             (nix == mtmp->mux && niy == mtmp->muy)) {
  1185. X          mtmp2 = 
  1186. X              (MON_AT(nix, niy) ? m_at(nix,niy) : (struct monst *)0);
  1187. X!         if(mattackm(mtmp, mtmp2) == 1 && rn2(4) &&
  1188. X              mtmp2->mlstmv != moves && mattackm(mtmp2, mtmp) == 2)
  1189. X              return(2);
  1190. X          return(3);
  1191. X          }
  1192. X  #ifdef WORM
  1193. X--- 623,635 ----
  1194. X           */
  1195. X          if((info[chi] & ALLOW_M) ||
  1196. X             (nix == mtmp->mux && niy == mtmp->muy)) {
  1197. X+         int stat;
  1198. X          mtmp2 = 
  1199. X              (MON_AT(nix, niy) ? m_at(nix,niy) : (struct monst *)0);
  1200. X!         if((stat = mattackm(mtmp, mtmp2)) == 1 && rn2(4) &&
  1201. X              mtmp2->mlstmv != moves && mattackm(mtmp2, mtmp) == 2)
  1202. X              return(2);
  1203. X+         if(stat == -1) return(2);
  1204. X          return(3);
  1205. X          }
  1206. X  #ifdef WORM
  1207. X***************
  1208. X*** 616,629 ****
  1209. X          /* open a door, or crash through it, if you can */
  1210. X          if(IS_DOOR(levl[mtmp->mx][mtmp->my].typ)
  1211. X              && !passes_walls(ptr) /* doesn't need to open doors */
  1212. X-                 && !amorphous(ptr) /* ditto */
  1213. X              && !can_tunnel /* taken care of below */
  1214. X            ) {
  1215. X          struct rm *here = &levl[mtmp->mx][mtmp->my];
  1216. X          boolean btrapped = (here->doormask & D_TRAPPED);
  1217. X  
  1218. X!         if(here->doormask & D_LOCKED && mtmp->isshk) {
  1219. X!             /* can't lock out shk */
  1220. X              if(btrapped) {
  1221. X              here->doormask = D_NODOOR;
  1222. X              mnewsym(mtmp->mx, mtmp->my);
  1223. X--- 664,679 ----
  1224. X          /* open a door, or crash through it, if you can */
  1225. X          if(IS_DOOR(levl[mtmp->mx][mtmp->my].typ)
  1226. X              && !passes_walls(ptr) /* doesn't need to open doors */
  1227. X              && !can_tunnel /* taken care of below */
  1228. X            ) {
  1229. X          struct rm *here = &levl[mtmp->mx][mtmp->my];
  1230. X          boolean btrapped = (here->doormask & D_TRAPPED);
  1231. X  
  1232. X!         if(here->doormask & (D_LOCKED|D_CLOSED) && amorphous(ptr)) {
  1233. X!             if (flags.verbose && canseeit)
  1234. X!             pline("%s %ss under the door.", Monnam(mtmp),
  1235. X!                   ptr == &mons[PM_FOG_CLOUD] ? "flow" : "ooze");
  1236. X!         } else if(here->doormask & D_LOCKED && can_unlock) {
  1237. X              if(btrapped) {
  1238. X              here->doormask = D_NODOOR;
  1239. X              mnewsym(mtmp->mx, mtmp->my);
  1240. X***************
  1241. X*** 640,647 ****
  1242. X              mnewsym(mtmp->mx, mtmp->my);
  1243. X              if (canseeit) prl(mtmp->mx,mtmp->my);
  1244. X              }
  1245. X!         } else if (here->doormask == D_CLOSED && 
  1246. X!                     !nohands(mtmp->data)) {
  1247. X              if(btrapped) {
  1248. X              here->doormask = D_NODOOR;
  1249. X              mnewsym(mtmp->mx, mtmp->my);
  1250. X--- 690,696 ----
  1251. X              mnewsym(mtmp->mx, mtmp->my);
  1252. X              if (canseeit) prl(mtmp->mx,mtmp->my);
  1253. X              }
  1254. X!         } else if (here->doormask == D_CLOSED && can_open) {
  1255. X              if(btrapped) {
  1256. X              here->doormask = D_NODOOR;
  1257. X              mnewsym(mtmp->mx, mtmp->my);
  1258. X***************
  1259. X*** 658,665 ****
  1260. X              mnewsym(mtmp->mx, mtmp->my);
  1261. X              if (canseeit) prl(mtmp->mx,mtmp->my);
  1262. X              }
  1263. X!         } else if(here->doormask & (D_LOCKED | D_CLOSED)) {
  1264. X!             /* mfndpos guarantees monster is a giant */
  1265. X              if(btrapped) {
  1266. X              here->doormask = D_NODOOR;
  1267. X              mnewsym(mtmp->mx, mtmp->my);
  1268. X--- 707,714 ----
  1269. X              mnewsym(mtmp->mx, mtmp->my);
  1270. X              if (canseeit) prl(mtmp->mx,mtmp->my);
  1271. X              }
  1272. X!         } else if (here->doormask & (D_LOCKED|D_CLOSED)) {
  1273. X!                /* mfndpos guarantees this must be a doorbuster */
  1274. X              if(btrapped) {
  1275. X              here->doormask = D_NODOOR;
  1276. X              mnewsym(mtmp->mx, mtmp->my);
  1277. X***************
  1278. X*** 683,696 ****
  1279. X          /* Maybe a rock mole just ate something? */
  1280. X          if(can_tunnel) if(!mdig_tunnel(mtmp)) return(2); /* died? */
  1281. X  
  1282. X!         if(levl[mtmp->mx][mtmp->my].gmask == 1) {
  1283. X          /* Maybe a rock mole just ate some gold */
  1284. X!         if(ptr == &mons[PM_ROCK_MOLE]) meatgold(mtmp);
  1285. X          if(likegold && (!abstain || !rn2(10))) mpickgold(mtmp);
  1286. X          }
  1287. X          if(OBJ_AT(mtmp->mx, mtmp->my)) {
  1288. X          /* Maybe a rock mole just ate some metal object */
  1289. X!         if(ptr == &mons[PM_ROCK_MOLE]) meatgold(mtmp);
  1290. X          /* Maybe a cube ate just about anything */
  1291. X          if(ptr == &mons[PM_GELATINOUS_CUBE]) meatobj(mtmp);
  1292. X  
  1293. X--- 732,745 ----
  1294. X          /* Maybe a rock mole just ate something? */
  1295. X          if(can_tunnel) if(!mdig_tunnel(mtmp)) return(2); /* died? */
  1296. X  
  1297. X!         if(levl[mtmp->mx][mtmp->my].gmask == TRUE) {
  1298. X          /* Maybe a rock mole just ate some gold */
  1299. X!         if(metallivorous(ptr)) meatgold(mtmp);
  1300. X          if(likegold && (!abstain || !rn2(10))) mpickgold(mtmp);
  1301. X          }
  1302. X          if(OBJ_AT(mtmp->mx, mtmp->my)) {
  1303. X          /* Maybe a rock mole just ate some metal object */
  1304. X!         if(metallivorous(ptr)) meatgold(mtmp);
  1305. X          /* Maybe a cube ate just about anything */
  1306. X          if(ptr == &mons[PM_GELATINOUS_CUBE]) meatobj(mtmp);
  1307. X  
  1308. X***************
  1309. X*** 720,725 ****
  1310. X--- 769,795 ----
  1311. X      return(mmoved);
  1312. X  }
  1313. X  
  1314. X+ #endif /* OVL0 */
  1315. X+ #ifdef OVL2
  1316. X+ 
  1317. X+ boolean
  1318. X+ closed_door(x, y)
  1319. X+ register int x, y;
  1320. X+ {
  1321. X+     return(IS_DOOR(levl[x][y].typ) &&
  1322. X+             (levl[x][y].doormask & (D_LOCKED | D_CLOSED)));
  1323. X+ }
  1324. X+ 
  1325. X+ boolean
  1326. X+ accessible(x, y)
  1327. X+ register int x, y;
  1328. X+ {
  1329. X+     return(ACCESSIBLE(levl[x][y].typ) && !closed_door(x, y));
  1330. X+ }
  1331. X+ 
  1332. X+ #endif /* OVL2 */
  1333. X+ #ifdef OVL1
  1334. X+ 
  1335. X  void
  1336. X  set_apparxy(mtmp)        /* where does mtmp think you are standing? */
  1337. X      register struct monst *mtmp;
  1338. X***************
  1339. X*** 748,765 ****
  1340. X          mtmp->mux = u.ux - disp + rn2(2*disp+1);
  1341. X          mtmp->muy = u.uy - disp + rn2(2*disp+1);
  1342. X      } while((mtmp->mux != u.ux || mtmp->muy != u.uy) &&
  1343. X!            (  (!passes_walls(mtmp->data) &&
  1344. X                (!ACCESSIBLE(levl[mtmp->mux][mtmp->muy].typ) ||
  1345. X!                (IS_DOOR(levl[mtmp->mux][mtmp->muy].typ) &&
  1346. X!             (levl[mtmp->mux][mtmp->muy].doormask & (D_LOCKED | D_CLOSED)) &&
  1347. X              !amorphous(mtmp->data)
  1348. X!               ))
  1349. X            ) ||
  1350. X            (disp==1 && mtmp->mux == mtmp->mx && mtmp->muy == mtmp->my)
  1351. X!            )
  1352. X!     );
  1353. X  }
  1354. X  
  1355. X  #ifdef STUPID_CPP    /* otherwise these functions are macros in rm.h */
  1356. X  /*
  1357. X   * Functions for encapsulation of level.monsters references.
  1358. X--- 818,838 ----
  1359. X          mtmp->mux = u.ux - disp + rn2(2*disp+1);
  1360. X          mtmp->muy = u.uy - disp + rn2(2*disp+1);
  1361. X      } while((mtmp->mux != u.ux || mtmp->muy != u.uy) &&
  1362. X!             ( (!passes_walls(mtmp->data) &&
  1363. X                (!ACCESSIBLE(levl[mtmp->mux][mtmp->muy].typ) ||
  1364. X!                (closed_door(mtmp->mux, mtmp->muy) &&
  1365. X              !amorphous(mtmp->data)
  1366. X!                )
  1367. X!               )
  1368. X            ) ||
  1369. X            (disp==1 && mtmp->mux == mtmp->mx && mtmp->muy == mtmp->my)
  1370. X!             )
  1371. X!            );
  1372. X  }
  1373. X  
  1374. X+ #endif /* OVL1 */
  1375. X+ #ifdef OVLB
  1376. X+ 
  1377. X  #ifdef STUPID_CPP    /* otherwise these functions are macros in rm.h */
  1378. X  /*
  1379. X   * Functions for encapsulation of level.monsters references.
  1380. X***************
  1381. X*** 799,801 ****
  1382. X--- 872,876 ----
  1383. X      return(level.monsters[x][y]);
  1384. X  }
  1385. X  #endif    /* STUPID_CPP */
  1386. X+ 
  1387. X+ #endif /* OVLB */
  1388. X
  1389. X*** src/Old/write.c    Mon Feb 19 19:10:15 1990
  1390. X--- src/write.c    Thu Jan 25 22:16:35 1990
  1391. X***************
  1392. X*** 4,9 ****
  1393. X--- 4,11 ----
  1394. X  
  1395. X  #include "hack.h"
  1396. X  
  1397. X+ static int FDECL(cost,(struct obj *));
  1398. X+ 
  1399. X  /*
  1400. X   * returns basecost of a scroll
  1401. X   */
  1402. X***************
  1403. X*** 109,114 ****
  1404. X--- 111,117 ----
  1405. X         newscroll->otyp == SCR_BLANK_PAPER)  {
  1406. X          You("can't write that!");
  1407. X          pline("It's obscene!");
  1408. X+         obfree(newscroll, (struct obj *) 0); /* pb@ethz.uucp */
  1409. X          return;
  1410. X      }
  1411. X      
  1412. X*** src/Old/zap.c    Mon Feb 19 19:10:33 1990
  1413. X--- src/zap.c    Wed Feb 14 17:54:22 1990
  1414. X***************
  1415. X*** 8,13 ****
  1416. X--- 8,26 ----
  1417. X  static boolean priesthit = FALSE;
  1418. X  #endif
  1419. X  
  1420. X+ static int FDECL(burn_floor_paper,(int,int));
  1421. X+ #ifndef OVERLAY
  1422. X+ static int FDECL(bhitm,(struct monst *,struct obj *));
  1423. X+ #endif
  1424. X+ static void FDECL(cancel_item,(struct obj *));
  1425. X+ static int FDECL(bhitgold,(struct gold *,struct obj *));
  1426. X+ #ifndef OVERLAY
  1427. X+ static int FDECL(bhito,(struct obj *,struct obj *));
  1428. X+ #endif
  1429. X+ static void FDECL(backfire,(struct obj *));
  1430. X+ static uchar FDECL(dirlet,(int,int));
  1431. X+ static int FDECL(zhit,(struct monst *,int,int));
  1432. X+ 
  1433. X  const char *fl[]= {
  1434. X      "magic missile",    /* Wands must be 0-9 */
  1435. X      "bolt of fire",
  1436. X***************
  1437. X*** 76,84 ****
  1438. X  #ifdef SPELLS
  1439. X      case SPE_SLOW_MONSTER:
  1440. X  #endif
  1441. X!         if(! resist(mtmp, otmp->olet, 0, NOTELL))
  1442. X              if (mtmp->mspeed == MFAST) mtmp->mspeed = 0;
  1443. X              else mtmp->mspeed = MSLOW;
  1444. X          break;
  1445. X      case WAN_SPEED_MONSTER:
  1446. X          if (!resist(mtmp, otmp->olet, 0, NOTELL))
  1447. X--- 89,104 ----
  1448. X  #ifdef SPELLS
  1449. X      case SPE_SLOW_MONSTER:
  1450. X  #endif
  1451. X!         if(! resist(mtmp, otmp->olet, 0, NOTELL)) {
  1452. X              if (mtmp->mspeed == MFAST) mtmp->mspeed = 0;
  1453. X              else mtmp->mspeed = MSLOW;
  1454. X+             if (u.uswallow && (mtmp == u.ustuck) && 
  1455. X+                 is_whirly(mtmp->data)) {
  1456. X+                 You("disrupt %s!", mon_nam(mtmp));
  1457. X+                 pline("A huge hole opens up...");
  1458. X+                 expels(mtmp, mtmp->data, TRUE);
  1459. X+             }
  1460. X+         }
  1461. X          break;
  1462. X      case WAN_SPEED_MONSTER:
  1463. X          if (!resist(mtmp, otmp->olet, 0, NOTELL))
  1464. X***************
  1465. X*** 149,157 ****
  1466. X  #endif
  1467. X      case WAN_OPENING:
  1468. X          if(u.uswallow && mtmp == u.ustuck) {
  1469. X!             if (Blind) pline("Its mouth opens!");
  1470. X!             else pline("%s opens its mouth!", Monnam(mtmp));
  1471. X!             regurgitates(mtmp);
  1472. X              break;
  1473. X          }
  1474. X      case WAN_LOCKING:
  1475. X--- 169,179 ----
  1476. X  #endif
  1477. X      case WAN_OPENING:
  1478. X          if(u.uswallow && mtmp == u.ustuck) {
  1479. X!             if (is_animal(mtmp->data)) {
  1480. X!                 if (Blind) pline("Its mouth opens!");
  1481. X!                 else pline("%s opens its mouth!", Monnam(mtmp));
  1482. X!             }
  1483. X!             expels(mtmp, mtmp->data, TRUE);
  1484. X              break;
  1485. X          }
  1486. X      case WAN_LOCKING:
  1487. X***************
  1488. X*** 190,202 ****
  1489. X              if (is_mercenary(&mons[montype]))
  1490. X                  montype = PM_UNARMORED_SOLDIER;
  1491. X  #endif
  1492. X-             mons[montype].pxlth += obj->onamelth;
  1493. X              mtmp = makemon(&mons[montype], x, y);
  1494. X-             mons[montype].pxlth -= obj->onamelth;
  1495. X              if (mtmp) {
  1496. X                  /* Monster retains its name */
  1497. X!                 if (mtmp->mnamelth = obj->onamelth)
  1498. X!                     Strcpy(NAME(mtmp), ONAME(obj));
  1499. X                  /* No inventory for newly revived monsters */
  1500. X                  while(otmp = (mtmp->minvent)) {
  1501. X                      mtmp->minvent = otmp->nobj;
  1502. X--- 212,222 ----
  1503. X              if (is_mercenary(&mons[montype]))
  1504. X                  montype = PM_UNARMORED_SOLDIER;
  1505. X  #endif
  1506. X              mtmp = makemon(&mons[montype], x, y);
  1507. X              if (mtmp) {
  1508. X                  /* Monster retains its name */
  1509. X!                 if (obj->onamelth)
  1510. X!                     mtmp = christen_monst(mtmp, ONAME(obj));
  1511. X                  /* No inventory for newly revived monsters */
  1512. X                  while(otmp = (mtmp->minvent)) {
  1513. X                      mtmp->minvent = otmp->nobj;
  1514. X***************
  1515. X*** 207,214 ****
  1516. X          if (mtmp && obj->oeaten)
  1517. X              mtmp->mhp = eaten_stat(mtmp->mhp, obj);
  1518. X          if (ininv) useup(obj);
  1519. X!         else useupf(obj);
  1520. X!         newsym(x, y);
  1521. X      }
  1522. X      return mtmp;
  1523. X  }
  1524. X--- 227,239 ----
  1525. X          if (mtmp && obj->oeaten)
  1526. X              mtmp->mhp = eaten_stat(mtmp->mhp, obj);
  1527. X          if (ininv) useup(obj);
  1528. X!         else {
  1529. X!             /* not useupf(), which charges */
  1530. X!             if (obj->quan > 1) obj->quan--;
  1531. X!             else delobj(obj);
  1532. X!         }
  1533. X!         if (x != u.ux || y != u.uy || Invisible)
  1534. X!             newsym(x, y);
  1535. X      }
  1536. X      return mtmp;
  1537. X  }
  1538. X***************
  1539. X*** 219,224 ****
  1540. X--- 244,272 ----
  1541. X  cancel_item(obj)
  1542. X  register struct obj *obj;
  1543. X  {
  1544. X+     switch(obj->otyp) {
  1545. X+         case RIN_GAIN_STRENGTH:
  1546. X+             ABON(A_STR) -= obj->spe;
  1547. X+             flags.botl = 1;
  1548. X+             break;
  1549. X+         case RIN_ADORNMENT:
  1550. X+             ABON(A_CHA) -= obj->spe;
  1551. X+             flags.botl = 1;
  1552. X+             break;
  1553. X+         case RIN_INCREASE_DAMAGE:
  1554. X+             u.udaminc -= obj->spe;
  1555. X+             break;
  1556. X+         case GAUNTLETS_OF_DEXTERITY:
  1557. X+             ABON(A_DEX) -= obj->spe;
  1558. X+             flags.botl = 1;
  1559. X+             break;
  1560. X+         case HELM_OF_BRILLIANCE:
  1561. X+             ABON(A_INT) -= obj->spe;
  1562. X+             ABON(A_WIS) -= obj->spe;
  1563. X+             flags.botl = 1;
  1564. X+             break;
  1565. X+         /* case RIN_PROTECTION: /* not needed */
  1566. X+     }
  1567. X      if(obj->spe &&
  1568. X        !(obj->otyp == AMULET_OF_YENDOR ||
  1569. X          obj->otyp == WAN_CANCELLATION || /* can't cancel cancellation */
  1570. X***************
  1571. X*** 290,296 ****
  1572. X           */
  1573. X          if (obj->otyp == SCR_MAIL) {
  1574. X              otmp2->otyp = SCR_MAIL;
  1575. X!             obj->spe = 1;
  1576. X          }
  1577. X  #endif
  1578. X          /* keep special fields (including charges on wands) */
  1579. X--- 338,344 ----
  1580. X           */
  1581. X          if (obj->otyp == SCR_MAIL) {
  1582. X              otmp2->otyp = SCR_MAIL;
  1583. X!             otmp2->spe = 1;
  1584. X          }
  1585. X  #endif
  1586. X          /* keep special fields (including charges on wands) */
  1587. X***************
  1588. X*** 341,346 ****
  1589. X--- 389,405 ----
  1590. X              }
  1591. X          }
  1592. X  
  1593. X+         /* no named weapons --KAA */
  1594. X+         if (otmp2->onamelth) {
  1595. X+             otmp2 = oname(otmp2, "", 0);
  1596. X+             fobj = otmp2;
  1597. X+             /* cannot use place_object() */
  1598. X+             level.objects[otmp2->ox][otmp2->oy] = otmp2;
  1599. X+         }
  1600. X+ 
  1601. X+         /* no box contents --KAA */
  1602. X+         if (Is_container(otmp2)) delete_contents(otmp2);
  1603. X+ 
  1604. X          /* update the weight */
  1605. X          otmp2->owt = weight(otmp2);
  1606. X          delobj(obj);
  1607. X***************
  1608. X*** 447,454 ****
  1609. X              }
  1610. X              break;
  1611. X          case WAN_WISHING:
  1612. X! 
  1613. X!             if(u.uluck + rn2(5) < 0) {
  1614. X                  pline("Unfortunately, nothing happens.");
  1615. X                  break;
  1616. X              }
  1617. X--- 506,512 ----
  1618. X              }
  1619. X              break;
  1620. X          case WAN_WISHING:
  1621. X!             if(Luck + rn2(5) < 0) {
  1622. X                  pline("Unfortunately, nothing happens.");
  1623. X                  break;
  1624. X              }
  1625. X***************
  1626. X*** 467,473 ****
  1627. X      register struct obj * otmp;
  1628. X  {
  1629. X      pline("The %s suddenly explodes!", xname(otmp));
  1630. X!     losehp(d(otmp->spe+2,6), "exploding wand");
  1631. X      useup(otmp);
  1632. X  }
  1633. X  
  1634. X--- 525,531 ----
  1635. X      register struct obj * otmp;
  1636. X  {
  1637. X      pline("The %s suddenly explodes!", xname(otmp));
  1638. X!     losehp(d(otmp->spe+2,6), "exploding wand", KILLED_BY_AN);
  1639. X      useup(otmp);
  1640. X  }
  1641. X  
  1642. X***************
  1643. X*** 495,501 ****
  1644. X          /* make him pay for knowing !NODIR */
  1645. X      } else if(!u.dx && !u.dy && !u.dz && !(objects[obj->otyp].bits & NODIR)) {
  1646. X          if((damage = zapyourself(obj)))
  1647. X!         losehp(damage,"self-inflicted injury");
  1648. X      }
  1649. X      else {
  1650. X          weffects(obj);
  1651. X--- 553,560 ----
  1652. X          /* make him pay for knowing !NODIR */
  1653. X      } else if(!u.dx && !u.dy && !u.dz && !(objects[obj->otyp].bits & NODIR)) {
  1654. X          if((damage = zapyourself(obj)))
  1655. X!         losehp(damage, self_pronoun("zapped %sself with a wand", "him"),
  1656. X!             NO_KILLER_PREFIX);
  1657. X      }
  1658. X      else {
  1659. X          weffects(obj);
  1660. X***************
  1661. X*** 698,704 ****
  1662. X              break;
  1663. X              }
  1664. X  #endif
  1665. X!             killer = "death ray";
  1666. X              You("irradiate yourself with pure energy!");
  1667. X              You("die.");
  1668. X              makeknown(WAN_DEATH);
  1669. X--- 757,764 ----
  1670. X              break;
  1671. X              }
  1672. X  #endif
  1673. X!             killer_format = NO_KILLER_PREFIX;
  1674. X!             killer = self_pronoun("shot %sself with a death ray","him");
  1675. X              You("irradiate yourself with pure energy!");
  1676. X              You("die.");
  1677. X              makeknown(WAN_DEATH);
  1678. X***************
  1679. X*** 711,717 ****
  1680. X          case WAN_UNDEAD_TURNING:
  1681. X  #ifdef POLYSELF
  1682. X              if (is_undead(uasmon)) {
  1683. X!             Printf("You feel frightened and %sstunned.",
  1684. X                   Stunned ? "even more " : "");
  1685. X              make_stunned(HStun + rnd(30), FALSE);
  1686. X              }
  1687. X--- 771,777 ----
  1688. X          case WAN_UNDEAD_TURNING:
  1689. X  #ifdef POLYSELF
  1690. X              if (is_undead(uasmon)) {
  1691. X!             You("feel frightened and %sstunned.",
  1692. X                   Stunned ? "even more " : "");
  1693. X              make_stunned(HStun + rnd(30), FALSE);
  1694. X              }
  1695. X***************
  1696. X*** 799,805 ****
  1697. X              }
  1698. X              break;
  1699. X          case WAN_WISHING:
  1700. X!             if(u.uluck + rn2(5) < 0) {
  1701. X                  pline("Unfortunately, nothing happens.");
  1702. X                  break;
  1703. X              }
  1704. X--- 859,865 ----
  1705. X              }
  1706. X              break;
  1707. X          case WAN_WISHING:
  1708. X!             if(Luck + rn2(5) < 0) {
  1709. X                  pline("Unfortunately, nothing happens.");
  1710. X                  break;
  1711. X              }
  1712. X***************
  1713. X*** 819,832 ****
  1714. X              { register struct rm *room;
  1715. X                register int digdepth,dlx,dly;
  1716. X                register boolean shopdoor = FALSE;
  1717. X              if(u.uswallow) {
  1718. X                  register struct monst *mtmp = u.ustuck;
  1719. X  
  1720. X!                 if (Blind) You("pierce its stomach wall!");
  1721. X!                 else You("pierce %s's stomach wall!",
  1722. X!                     mon_nam(mtmp));
  1723. X!                 mtmp->mhp = 1;    /* almost dead */
  1724. X!                 regurgitates(mtmp);
  1725. X                  break;
  1726. X              }
  1727. X              if(u.dz) {
  1728. X--- 879,901 ----
  1729. X              { register struct rm *room;
  1730. X                register int digdepth,dlx,dly;
  1731. X                register boolean shopdoor = FALSE;
  1732. X+ #ifdef __GNULINT__
  1733. X+             dlx = dly = 0;
  1734. X+ #endif
  1735. X              if(u.uswallow) {
  1736. X                  register struct monst *mtmp = u.ustuck;
  1737. X  
  1738. X!                 if (!is_whirly(mtmp->data)) {
  1739. X!                     if (is_animal(mtmp->data)) 
  1740. X!                         if (Blind) 
  1741. X!                         You("pierce its stomach wall!");
  1742. X!                         else 
  1743. X!                         You("pierce %s's stomach wall!",
  1744. X!                                mon_nam(mtmp));
  1745. X!                     mtmp->mhp = 1;    /* almost dead */
  1746. X!                     expels(mtmp, mtmp->data,
  1747. X!                            !is_animal(mtmp->data));
  1748. X!                 }
  1749. X                  break;
  1750. X              }
  1751. X              if(u.dz) {
  1752. X***************
  1753. X*** 834,840 ****
  1754. X                  You("loosen a rock from the ceiling.");
  1755. X                  pline("It falls on your %s!",
  1756. X                      body_part(HEAD));
  1757. X!                 losehp(1, "falling rock");
  1758. X                  (void) mksobj_at((int)ROCK, u.ux, u.uy);
  1759. X                  fobj->quan = 1;
  1760. X                  stackobj(fobj);
  1761. X--- 903,909 ----
  1762. X                  You("loosen a rock from the ceiling.");
  1763. X                  pline("It falls on your %s!",
  1764. X                      body_part(HEAD));
  1765. X!                 losehp(1, "falling rock", KILLED_BY_AN);
  1766. X                  (void) mksobj_at((int)ROCK, u.ux, u.uy);
  1767. X                  fobj->quan = 1;
  1768. X                  stackobj(fobj);
  1769. X***************
  1770. X*** 883,890 ****
  1771. X                      }
  1772. X                      else
  1773. X                      break;
  1774. X!                 else if(room->typ == DOOR &&
  1775. X!                     (room->doormask & (D_LOCKED | D_CLOSED))) {
  1776. X                      room->doormask = D_NODOOR;
  1777. X                      mnewsym(zx, zy);
  1778. X                      if (cansee(zx,zy)) prl(zx, zy);
  1779. X--- 952,958 ----
  1780. X                      }
  1781. X                      else
  1782. X                      break;
  1783. X!                 else if(closed_door(zx, zy)) {
  1784. X                      room->doormask = D_NODOOR;
  1785. X                      mnewsym(zx, zy);
  1786. X                      if (cansee(zx,zy)) prl(zx, zy);
  1787. X***************
  1788. X*** 927,933 ****
  1789. X      return;
  1790. X  }
  1791. X  
  1792. X! char *
  1793. X  exclam(force)
  1794. X  register int force;
  1795. X  {
  1796. X--- 995,1001 ----
  1797. X      return;
  1798. X  }
  1799. X  
  1800. X! const char *
  1801. X  exclam(force)
  1802. X  register int force;
  1803. X  {
  1804. X***************
  1805. X*** 934,940 ****
  1806. X      /* force == 0 occurs e.g. with sleep ray */
  1807. X      /* note that large force is usual with wands so that !! would
  1808. X          require information about hand/weapon/wand */
  1809. X!     return( (force < 0) ? "?" : (force <= 4) ? "." : "!" );
  1810. X  }
  1811. X  
  1812. X  void
  1813. X--- 1002,1008 ----
  1814. X      /* force == 0 occurs e.g. with sleep ray */
  1815. X      /* note that large force is usual with wands so that !! would
  1816. X          require information about hand/weapon/wand */
  1817. X!     return (const char *)((force < 0) ? "?" : (force <= 4) ? "." : "!");
  1818. X  }
  1819. X  
  1820. X  void
  1821. X***************
  1822. X*** 968,974 ****
  1823. X  bhit(ddx,ddy,range,sym,fhitm,fhito,obj)
  1824. X  register int ddx,ddy,range;        /* direction and range */
  1825. X  char sym;                /* symbol displayed on path */
  1826. X! int (*fhitm)(), (*fhito)();        /* fns called when mon/obj hit */
  1827. X  struct obj *obj;            /* 2nd arg to fhitm/fhito */
  1828. X  {
  1829. X      register struct monst *mtmp;
  1830. X--- 1036,1043 ----
  1831. X  bhit(ddx,ddy,range,sym,fhitm,fhito,obj)
  1832. X  register int ddx,ddy,range;        /* direction and range */
  1833. X  char sym;                /* symbol displayed on path */
  1834. X! int FDECL((*fhitm), (struct monst *, struct obj *)),
  1835. X!     FDECL((*fhito), (struct obj *, struct obj *));        /* fns called when mon/obj hit */
  1836. X  struct obj *obj;            /* 2nd arg to fhitm/fhito */
  1837. X  {
  1838. X      register struct monst *mtmp;
  1839. X***************
  1840. X*** 975,981 ****
  1841. X--- 1044,1054 ----
  1842. X      register struct obj *otmp;
  1843. X      register uchar typ;
  1844. X      boolean shopdoor = FALSE;
  1845. X+ #ifdef __GNULINT__
  1846. X+     xchar dlx=0, dly=0;
  1847. X+ #else
  1848. X      xchar dlx, dly;
  1849. X+ #endif
  1850. X  
  1851. X      bhitpos.x = u.ux;
  1852. X      bhitpos.y = u.uy;
  1853. X***************
  1854. X*** 1063,1071 ****
  1855. X                  break;
  1856. X              }
  1857. X          }
  1858. X!         if(!ZAP_POS(typ) || (IS_DOOR(typ) &&
  1859. X!            (levl[bhitpos.x][bhitpos.y].doormask & (D_LOCKED | D_CLOSED)))
  1860. X!           ) {
  1861. X              bhitpos.x -= ddx;
  1862. X              bhitpos.y -= ddy;
  1863. X              break;
  1864. X--- 1136,1142 ----
  1865. X                  break;
  1866. X              }
  1867. X          }
  1868. X!         if(!ZAP_POS(typ) || closed_door(bhitpos.x, bhitpos.y)) {
  1869. X              bhitpos.x -= ddx;
  1870. X              bhitpos.y -= ddy;
  1871. X              break;
  1872. X***************
  1873. X*** 1179,1185 ****
  1874. X          if(resists_sleep(mon->data) ||
  1875. X             resist(mon, (type == 2) ? WAND_SYM : '\0', 0, NOTELL))
  1876. X              shieldeff(mon->mx, mon->my);
  1877. X!         else    mon->mfroz = 1;
  1878. X          break;
  1879. X      case 3:            /* cold */
  1880. X          if(resists_cold(mon->data)) {
  1881. X--- 1250,1261 ----
  1882. X          if(resists_sleep(mon->data) ||
  1883. X             resist(mon, (type == 2) ? WAND_SYM : '\0', 0, NOTELL))
  1884. X              shieldeff(mon->mx, mon->my);
  1885. X!         else if (mon->mcanmove) {
  1886. X!             int tmp2 = d(nd,25);
  1887. X!             mon->mcanmove = 0;
  1888. X!             if (mon->mfrozen + tmp2 > 127) mon->mfrozen = 127;
  1889. X!             else mon->mfrozen += tmp2;
  1890. X!         }
  1891. X          break;
  1892. X      case 3:            /* cold */
  1893. X          if(resists_cold(mon->data)) {
  1894. X***************
  1895. X*** 1256,1266 ****
  1896. X  #else
  1897. X          if(obj->olet == SCROLL_SYM) {
  1898. X  #endif
  1899. X          scrquan = obj->quan;
  1900. X          for(i = 1; i <= scrquan ; i++)
  1901. X              if(!rn2(3))  {
  1902. X              cnt++;
  1903. X!             useupf(obj);
  1904. X              }
  1905. X          }
  1906. X      }
  1907. X--- 1332,1349 ----
  1908. X  #else
  1909. X          if(obj->olet == SCROLL_SYM) {
  1910. X  #endif
  1911. X+         if (obj->otyp == SCR_FIRE
  1912. X+ #ifdef SPELLS
  1913. X+                     || obj->otyp == SPE_FIREBALL)
  1914. X+ #endif
  1915. X+             continue;
  1916. X          scrquan = obj->quan;
  1917. X          for(i = 1; i <= scrquan ; i++)
  1918. X              if(!rn2(3))  {
  1919. X              cnt++;
  1920. X!             /* not useupf(), which charges */
  1921. X!             if (obj->quan > 1) obj->quan--;
  1922. X!             else delobj(obj);
  1923. X              }
  1924. X          }
  1925. X      }
  1926. X***************
  1927. X*** 1282,1288 ****
  1928. X--- 1365,1376 ----
  1929. X      int abstype = abs(type) % 10;
  1930. X      register const char *fltxt = fl[abs(type)];
  1931. X      struct rm *lev;
  1932. X+     register xchar lsx, lsy;
  1933. X+ #ifdef __GNULINT__
  1934. X+     xchar range, olx=0, oly=0;
  1935. X+ #else
  1936. X      xchar range, olx, oly;
  1937. X+ #endif
  1938. X      struct monst *mon;
  1939. X      register boolean bodyhit = FALSE;
  1940. X      register boolean shopdoor = FALSE;
  1941. X***************
  1942. X*** 1306,1315 ****
  1943. X      Tmp_at2(-3, zapcolor[abstype]);
  1944. X  #endif
  1945. X      while(range-- > 0) {
  1946. X!         sx += dx;
  1947. X!         sy += dy;
  1948. X!         if((lev = &levl[sx][sy])->typ) Tmp_at2(sx,sy);
  1949. X!         else {
  1950. X              int bounce = 0;
  1951. X              if(cansee(sx-dx,sy-dy))
  1952. X                  pline("The %s bounces!", fltxt);
  1953. X--- 1394,1407 ----
  1954. X      Tmp_at2(-3, zapcolor[abstype]);
  1955. X  #endif
  1956. X      while(range-- > 0) {
  1957. X!         lsx = sx; sx += dx;
  1958. X!         lsy = sy; sy += dy;
  1959. X!         if((lev = &levl[sx][sy])->typ) {
  1960. X!             if((cansee(lsx,lsy) && cansee(sx,sy)) ||
  1961. X!                 (!cansee(lsx,lsy) && cansee(sx,sy) &&
  1962. X!                  (IS_DOOR(lev->typ) || IS_ROOM(lev->typ))))
  1963. X!                 Tmp_at2(sx,sy);
  1964. X!         } else {
  1965. X              int bounce = 0;
  1966. X              if(cansee(sx-dx,sy-dy))
  1967. X                  pline("The %s bounces!", fltxt);
  1968. X***************
  1969. X*** 1388,1394 ****
  1970. X              } else if(flags.soundok)
  1971. X                  You("hear a crackling sound.");
  1972. X          }
  1973. X!         if(IS_DOOR(lev->typ) && (lev->doormask & (D_LOCKED | D_CLOSED))) {
  1974. X              range = 0;
  1975. X              switch(abstype) {
  1976. X              case 1:
  1977. X--- 1480,1486 ----
  1978. X              } else if(flags.soundok)
  1979. X                  You("hear a crackling sound.");
  1980. X          }
  1981. X!         if(closed_door(sx, sy)) {
  1982. X              range = 0;
  1983. X              switch(abstype) {
  1984. X              case 1:
  1985. X***************
  1986. X*** 1545,1551 ****
  1987. X                      case 1:
  1988. X                          bodyhit = TRUE;
  1989. X                          if (uarmc) break;
  1990. X!         (void)(rust_dmg(uarm, "leather armor", 0, FALSE));
  1991. X                          break;
  1992. X                      case 2:
  1993. X          if (!rust_dmg(uarms, "wooden shield", 0, FALSE)) continue;
  1994. X--- 1637,1643 ----
  1995. X                      case 1:
  1996. X                          bodyhit = TRUE;
  1997. X                          if (uarmc) break;
  1998. X!         if (uarm) (void)(rust_dmg(uarm, xname(uarm), 0, FALSE));
  1999. X                          break;
  2000. X                      case 2:
  2001. X          if (!rust_dmg(uarms, "wooden shield", 0, FALSE)) continue;
  2002. X***************
  2003. X*** 1623,1629 ****
  2004. X                      dam = d(nd, 6);
  2005. X                      break;
  2006. X                  case 6:        /* poison */
  2007. X!                     poisoned("blast", A_DEX, "poisoned blast");
  2008. X                      break;
  2009. X                  case 7:        /* acid */
  2010. X                      pline("The acid burns!");
  2011. X--- 1715,1721 ----
  2012. X                      dam = d(nd, 6);
  2013. X                      break;
  2014. X                  case 6:        /* poison */
  2015. X!                     poisoned("blast", A_DEX, "poisoned blast", 15);
  2016. X                      break;
  2017. X                  case 7:        /* acid */
  2018. X                      pline("The acid burns!");
  2019. X***************
  2020. X*** 1632,1638 ****
  2021. X                      if(!rn2(6)) corrode_armor();
  2022. X                      break;
  2023. X                  }
  2024. X!                 losehp(dam,fltxt);
  2025. X              } else pline("The %s whizzes by you!",fltxt);
  2026. X              if (abstype == 5 && !Blind) { /* LIGHTNING */
  2027. X                      You("are blinded by the flash!");
  2028. X--- 1724,1730 ----
  2029. X                      if(!rn2(6)) corrode_armor();
  2030. X                      break;
  2031. X                  }
  2032. X!                 losehp(dam,fltxt, KILLED_BY_AN);
  2033. X              } else pline("The %s whizzes by you!",fltxt);
  2034. X              if (abstype == 5 && !Blind) { /* LIGHTNING */
  2035. X                      You("are blinded by the flash!");
  2036. X***************
  2037. X*** 1675,1682 ****
  2038. X          }
  2039. X      }
  2040. X      Tmp_at2(-1,-1);
  2041. X!     if(shopdoor && !in_shop(u.ux, u.uy))
  2042. X!         pay_for_door(olx, oly, abstype == 1 ? "burn away" :
  2043. X                         abstype == 3 ? "shatter" :
  2044. X                         abstype == 4 ? "disintegrate" :
  2045. X                         "destroy");
  2046. X--- 1767,1773 ----
  2047. X          }
  2048. X      }
  2049. X      Tmp_at2(-1,-1);
  2050. X!     if(shopdoor) pay_for_door(olx, oly, abstype == 1 ? "burn away" :
  2051. X                         abstype == 3 ? "shatter" :
  2052. X                         abstype == 4 ? "disintegrate" :
  2053. X                         "destroy");
  2054. X***************
  2055. X*** 1780,1786 ****
  2056. X      register struct obj *obj, *obj2;
  2057. X      register int quan, i, cnt, dmg, xresist, skip;
  2058. X      register int dindx;
  2059. X!     char *mult;
  2060. X  
  2061. X      for(obj = invent; obj; obj = obj2) {
  2062. X  
  2063. X--- 1871,1877 ----
  2064. X      register struct obj *obj, *obj2;
  2065. X      register int quan, i, cnt, dmg, xresist, skip;
  2066. X      register int dindx;
  2067. X!     const char *mult;
  2068. X  
  2069. X      for(obj = invent; obj; obj = obj2) {
  2070. X  
  2071. X***************
  2072. X*** 1787,1793 ****
  2073. X          obj2 = obj->nobj;
  2074. X          if(obj->olet != osym) continue; /* test only objs of type osym */
  2075. X          xresist = skip = 0;
  2076. X! 
  2077. X          switch(dmgtyp) {
  2078. X          case AD_COLD:
  2079. X              if(osym == POTION_SYM) {
  2080. X--- 1878,1886 ----
  2081. X          obj2 = obj->nobj;
  2082. X          if(obj->olet != osym) continue; /* test only objs of type osym */
  2083. X          xresist = skip = 0;
  2084. X! #ifdef __GNULINT__
  2085. X!         quan = dmg = dindx = 0;
  2086. X! #endif
  2087. X          switch(dmgtyp) {
  2088. X          case AD_COLD:
  2089. X              if(osym == POTION_SYM) {
  2090. X***************
  2091. X*** 1799,1807 ****
  2092. X          case AD_FIRE:
  2093. X              xresist = (Fire_resistance && obj->olet != POTION_SYM);
  2094. X  
  2095. X!             /* Let's say scrolls of fire are fire resistant */
  2096. X! 
  2097. X!             if (obj->otyp == SCR_FIRE)
  2098. X                skip++;
  2099. X              quan = obj->quan;
  2100. X              switch(osym) {
  2101. X--- 1892,1902 ----
  2102. X          case AD_FIRE:
  2103. X              xresist = (Fire_resistance && obj->olet != POTION_SYM);
  2104. X  
  2105. X!             if (obj->otyp == SCR_FIRE
  2106. X! #ifdef SPELLS
  2107. X!                     || obj->otyp == SPE_FIREBALL
  2108. X! #endif
  2109. X!                                 )
  2110. X                skip++;
  2111. X              quan = obj->quan;
  2112. X              switch(osym) {
  2113. X***************
  2114. X*** 1863,1869 ****
  2115. X          for(i = 0; i < cnt; i++) useup(obj);
  2116. X          if(dmg) {
  2117. X              if(xresist)    You("aren't hurt!");
  2118. X!             else    losehp(dmg, destroy_strings[dindx*3 + 2]);
  2119. X          }
  2120. X          }
  2121. X      }
  2122. X--- 1958,1967 ----
  2123. X          for(i = 0; i < cnt; i++) useup(obj);
  2124. X          if(dmg) {
  2125. X              if(xresist)    You("aren't hurt!");
  2126. X!             else    losehp(dmg,
  2127. X!             (cnt==1) ? destroy_strings[dindx*3 + 2] :
  2128. X!                 (const char *)makeplural(destroy_strings[dindx*3 + 2]),
  2129. X!             (cnt==1) ? KILLED_BY_AN : KILLED_BY);
  2130. X          }
  2131. X          }
  2132. X      }
  2133. X***************
  2134. X*** 1884,1890 ****
  2135. X          obj2 = obj->nobj;
  2136. X          if(obj->olet != osym) continue; /* test only objs of type osym */
  2137. X          skip = 0;
  2138. X! 
  2139. X          switch(dmgtyp) {
  2140. X          case AD_COLD:
  2141. X              if(osym == POTION_SYM) {
  2142. X--- 1982,1990 ----
  2143. X          obj2 = obj->nobj;
  2144. X          if(obj->olet != osym) continue; /* test only objs of type osym */
  2145. X          skip = 0;
  2146. X! #ifdef __GNULINT__
  2147. X!         quan = dindx = 0;
  2148. X! #endif
  2149. X          switch(dmgtyp) {
  2150. X          case AD_COLD:
  2151. X              if(osym == POTION_SYM) {
  2152. X***************
  2153. X*** 1894,1902 ****
  2154. X              } else skip++;
  2155. X                  break;
  2156. X          case AD_FIRE:
  2157. X!             /* Let's say scrolls of fire are fire resistant */
  2158. X! 
  2159. X!             if (obj->otyp == SCR_FIRE)
  2160. X                skip++;
  2161. X              quan = obj->quan;
  2162. X              switch(osym) {
  2163. X--- 1994,2004 ----
  2164. X              } else skip++;
  2165. X                  break;
  2166. X          case AD_FIRE:
  2167. X!             if (obj->otyp == SCR_FIRE
  2168. X! #ifdef SPELLS
  2169. X!                     || obj->otyp == SPE_FIREBALL
  2170. X! #endif
  2171. X!                                 )
  2172. X                skip++;
  2173. X              quan = obj->quan;
  2174. X              switch(osym) {
  2175. X***************
  2176. X*** 2036,2046 ****
  2177. X              prinv(otmp);
  2178. X              otmp->quan = mergquan;
  2179. X          }
  2180. X- #ifdef WIZARD
  2181. X-      if (!wizard)
  2182. X- #endif
  2183. X-         if(otmp->otyp == WAN_WISHING) otmp->recharged = 1;
  2184. X- 
  2185. X  #ifdef THEOLOGY
  2186. X          u.ublesscnt += rn1(100,50);  /* the gods take notice */
  2187. X  #endif
  2188. X--- 2138,2143 ----
  2189. X
  2190. END_OF_FILE
  2191. if test 53746 -ne `wc -c <'patch7.12'`; then
  2192.     echo shar: \"'patch7.12'\" unpacked with wrong size!
  2193. fi
  2194. # end of 'patch7.12'
  2195. fi
  2196. echo shar: End of archive 18 \(of 30\).
  2197. cp /dev/null ark18isdone
  2198. MISSING=""
  2199. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 ; do
  2200.     if test ! -f ark${I}isdone ; then
  2201.     MISSING="${MISSING} ${I}"
  2202.     fi
  2203. done
  2204. if test "${MISSING}" = "" ; then
  2205.     echo You have unpacked all 30 archives.
  2206.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2207. else
  2208.     echo You still need to unpack the following archives:
  2209.     echo "        " ${MISSING}
  2210. fi
  2211. ##  End of shell archive.
  2212. exit 0
  2213.